home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / copier / copier.py < prev    next >
Encoding:
Python Source  |  2009-10-09  |  13.8 KB  |  382 lines
  1. # -*- coding: utf-8 -*-
  2. #
  3. # (c) Copyright 2003-2007 Hewlett-Packard Development Company, L.P.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18. #
  19. # Author: Don Welch
  20. #
  21.  
  22. from __future__ import generators
  23.  
  24. # Std Lib
  25. import sys
  26. import os
  27. import os.path
  28. import time
  29. import threading
  30. import Queue
  31. from cStringIO import StringIO
  32.  
  33. # Local
  34. from base.g import *
  35. from base.codes import *
  36. from base import device, utils, status, pml
  37.  
  38. # Event queue values (UI ==> Copy thread)
  39. COPY_CANCELED = 1
  40.  
  41. # Update queue values (Copy thread ==> UI)
  42. STATUS_IDLE = 0
  43. STATUS_SETTING_UP = 1
  44. STATUS_WARMING_UP = 2
  45. STATUS_ACTIVE = 3
  46. STATUS_DONE = 4
  47. STATUS_ERROR = 5
  48.  
  49.  
  50. # PML Copier Only
  51. class PMLCopyDevice(device.Device):
  52.     def __init__(self, device_uri=None, printer_name=None, 
  53.                  service=None, callback=None):
  54.  
  55.         device.Device.__init__(self, device_uri, printer_name,
  56.                                service, callback)
  57.  
  58.         self.copy_thread = None
  59.  
  60.     def copy(self, num_copies=1, contrast=0, reduction=100,
  61.              quality=pml.COPIER_QUALITY_NORMAL, 
  62.              fit_to_page=pml.COPIER_FIT_TO_PAGE_ENABLED,
  63.              scan_style=SCAN_STYLE_FLATBED,
  64.              update_queue=None, event_queue=None): 
  65.  
  66.         if not self.isCopyActive():
  67.             self.copy_thread = PMLCopyThread(self, num_copies, contrast, reduction, quality, 
  68.                                              fit_to_page, scan_style, update_queue, event_queue)
  69.             self.copy_thread.start()
  70.             return True
  71.         else:
  72.             return False
  73.  
  74.     def isCopyActive(self):
  75.         if self.copy_thread is not None:
  76.             return self.copy_thread.isAlive()
  77.         else:
  78.             return False
  79.  
  80.     def waitForCopyThread(self):
  81.         if self.copy_thread is not None and \
  82.             self.copy_thread.isAlive():
  83.  
  84.             self.copy_thread.join()
  85.  
  86.  
  87.  
  88. class PMLCopyThread(threading.Thread):
  89.     def __init__(self, dev, num_copies, contrast, reduction, quality, 
  90.                  fit_to_page, scan_style, 
  91.                  update_queue=None, event_queue=None):
  92.  
  93.         threading.Thread.__init__(self)
  94.         self.dev = dev
  95.         self.num_copies = num_copies
  96.         self.contrast = contrast
  97.         self.reduction = reduction
  98.         self.quality = quality
  99.         self.fit_to_page = fit_to_page
  100.         self.scan_style = scan_style
  101.         self.event_queue = event_queue
  102.         self.update_queue = update_queue
  103.         self.prev_update = ''
  104.         self.copy_type = self.dev.copy_type
  105.         log.debug("Copy-type = %d" % self.copy_type)
  106.  
  107.     def run(self):
  108.         STATE_DONE = 0
  109.         STATE_ERROR = 5
  110.         STATE_ABORTED = 10
  111.         STATE_SUCCESS = 20
  112.         STATE_BUSY = 25
  113.         STATE_SET_TOKEN = 30
  114.         STATE_SETUP_STATE = 40
  115.         STATE_SETUP_PARAMS = 50
  116.         STATE_START = 60
  117.         STATE_ACTIVE = 70
  118.         STATE_RESET_TOKEN = 80
  119.  
  120. #       state = STATE_SET_TOKEN
  121.         state = STATE_SETUP_STATE
  122.  
  123.         while state != STATE_DONE: # ------------------------- Copier Thread
  124.             # revisit - Checking cancel and setting state here means
  125.             # every state can unconditionally transition to STATE_ABORTED.
  126.             # This has not been verified.
  127.             # if self.check_for_cancel():
  128.                 # state = STATE_ABORTED
  129.  
  130.             if state == STATE_ABORTED:
  131.                 log.debug("%s State: Aborted" % ("*"*20))
  132.                 self.write_queue(STATUS_DONE) # This was STATUS_ERROR.
  133.                 state = STATE_RESET_TOKEN
  134.  
  135.             if state == STATE_ERROR:
  136.                 log.debug("%s State: Error" % ("*"*20))
  137.                 self.write_queue(STATUS_ERROR)
  138.                 state = STATE_RESET_TOKEN
  139.  
  140.             elif state == STATE_SUCCESS:
  141.                 log.debug("%s State: Success" % ("*"*20))
  142.                 self.write_queue(STATUS_DONE)
  143.                 state = STATE_RESET_TOKEN
  144.  
  145.             elif state == STATE_BUSY:
  146.                 log.debug("%s State: Busy" % ("*"*20))
  147.                 self.write_queue(STATUS_ERROR)
  148.                 state = STATE_RESET_TOKEN
  149.  
  150.             elif state == STATE_SET_TOKEN:
  151.                 log.debug("%s State: Acquire copy token" % ("*"*20))
  152.  
  153.                 self.write_queue(STATUS_SETTING_UP)
  154.  
  155.                 try:
  156.                     result_code, token = self.dev.getPML(pml.OID_COPIER_TOKEN)
  157.                 except Error:
  158.                     log.debug("Unable to acquire copy token (1).")
  159.                     state = STATE_SETUP_STATE
  160.                 else:
  161.                     if result_code > pml.ERROR_MAX_OK:
  162.                         state = STATE_SETUP_STATE
  163.                         log.debug("Skipping token acquisition.")
  164.                     else:
  165.                         token = time.strftime("%d%m%Y%H:%M:%S", time.gmtime())
  166.                         log.debug("Setting token: %s" % token)
  167.                         try:
  168.                             self.dev.setPML(pml.OID_COPIER_TOKEN, token)
  169.                         except Error:
  170.                             log.error("Unable to acquire copy token (2).")
  171.                             state = STATUS_ERROR
  172.                         else:
  173.                             result_code, check_token = self.dev.getPML(pml.OID_COPIER_TOKEN)
  174.  
  175.                             if check_token == token:
  176.                                 state = STATE_SETUP_STATE
  177.                             else:
  178.                                 log.error("Unable to acquire copy token (3).")
  179.                                 state = STATE_ERROR
  180.  
  181.             elif state == STATE_SETUP_STATE:
  182.                 log.debug("%s State: Setup state" % ("*"*20))
  183.  
  184.                 if self.copy_type == COPY_TYPE_DEVICE:
  185.                     result_code, copy_state = self.dev.getPML(pml.OID_COPIER_JOB)
  186.  
  187.                     if copy_state == pml.COPIER_JOB_IDLE:
  188.                         self.dev.setPML(pml.OID_COPIER_JOB, pml.COPIER_JOB_SETUP)
  189.                         state = STATE_SETUP_PARAMS
  190.  
  191.                     else:
  192.                         state = STATE_BUSY
  193.  
  194.                 elif self.copy_type == COPY_TYPE_AIO_DEVICE:
  195.                     result_code, copy_state = self.dev.getPML(pml.OID_SCAN_TO_PRINTER)
  196.  
  197.                     if copy_state == pml.SCAN_TO_PRINTER_IDLE:
  198.                         state = STATE_SETUP_PARAMS
  199.  
  200.                     else:
  201.                         state = STATE_BUSY
  202.  
  203.  
  204.  
  205.             elif state == STATE_SETUP_PARAMS:
  206.                 log.debug("%s State: Setup Params" % ("*"*20))
  207.  
  208.                 if self.num_copies < 0: self.num_copies = 1
  209.                 if self.num_copies > 99: self.num_copies = 99
  210.  
  211.                 if self.copy_type == COPY_TYPE_DEVICE: # MFP
  212.  
  213.                     # num_copies
  214.                     self.dev.setPML(pml.OID_COPIER_JOB_NUM_COPIES, self.num_copies)
  215.  
  216.                     # contrast
  217.                     self.dev.setPML(pml.OID_COPIER_JOB_CONTRAST, self.contrast)
  218.  
  219.                     # reduction
  220.                     self.dev.setPML(pml.OID_COPIER_JOB_REDUCTION, self.reduction)
  221.  
  222.                     # quality
  223.                     self.dev.setPML(pml.OID_COPIER_JOB_QUALITY, self.quality)
  224.  
  225.                     # fit_to_page
  226.                     if self.scan_style == SCAN_STYLE_FLATBED:
  227.                         self.dev.setPML(pml.OID_COPIER_JOB_FIT_TO_PAGE, self.fit_to_page)
  228.  
  229.                 else: # AiO
  230.                     # num_copies
  231.                     self.dev.setPML(pml.OID_COPIER_NUM_COPIES_AIO, self.num_copies)
  232.  
  233.                     # contrast
  234.                     self.contrast = (self.contrast * 10 / 25) + 50
  235.                     self.dev.setPML(pml.OID_COPIER_CONTRAST_AIO, self.contrast)
  236.  
  237.                     if self.fit_to_page == pml.COPIER_FIT_TO_PAGE_ENABLED:
  238.                         self.reduction = 0
  239.  
  240.                     # reduction
  241.                     self.dev.setPML(pml.OID_COPIER_REDUCTION_AIO, self.reduction)
  242.  
  243.                     # quality
  244.                     self.dev.setPML(pml.OID_COPIER_QUALITY_AIO, self.quality)
  245.  
  246.                     self.dev.setPML(pml.OID_PIXEL_DATA_TYPE, pml.PIXEL_DATA_TYPE_COLOR_24_BIT)
  247.                     self.dev.setPML(pml.OID_COPIER_SPECIAL_FEATURES, pml.COPY_FEATURE_NONE)
  248.                     self.dev.setPML(pml.OID_COPIER_PHOTO_MODE, pml.ENHANCE_LIGHT_COLORS | pml.ENHANCE_TEXT)
  249.                     
  250.                     # tray select
  251.                     self.dev.setPML(pml.OID_COPIER_JOB_INPUT_TRAY_SELECT, pml.COPIER_JOB_INPUT_TRAY_1)
  252.                     
  253.                     # media type
  254.                     self.dev.setPML(pml.OID_COPIER_MEDIA_TYPE, pml.COPIER_MEDIA_TYPE_AUTOMATIC)
  255.                     
  256.                     # pixel data type
  257.                     self.dev.setPML(pml.OID_PIXEL_DATA_TYPE, pml.PIXEL_DATA_TYPE_COLOR_24_BIT)
  258.                     
  259.                     # special features
  260.                     self.dev.setPML(pml.OID_COPIER_SPECIAL_FEATURES, pml.COPY_FEATURE_NONE)
  261.                     
  262.                     # media size
  263.                     self.dev.setPML(pml.OID_COPIER_JOB_MEDIA_SIZE, pml.COPIER_JOB_MEDIA_SIZE_US_LETTER)
  264.                     
  265.  
  266.                 
  267.                 
  268.                 log.debug("num_copies = %d" % self.num_copies)
  269.                 log.debug("contrast= %d" % self.contrast)
  270.                 log.debug("reduction = %d" % self.reduction)
  271.                 log.debug("quality = %d" % self.quality)
  272.                 log.debug("fit_to_page = %d" % self.fit_to_page)
  273.  
  274.                 state = STATE_START
  275.  
  276.             elif state == STATE_START:
  277.                 log.debug("%s State: Start" % ("*"*20))
  278.  
  279.                 if self.copy_type == COPY_TYPE_DEVICE:
  280.                     self.dev.setPML(pml.OID_COPIER_JOB, pml.COPIER_JOB_START)
  281.  
  282.                 elif self.copy_type == COPY_TYPE_AIO_DEVICE:
  283.                     self.dev.setPML(pml.OID_SCAN_TO_PRINTER, pml.SCAN_TO_PRINTER_START)
  284.  
  285.                 state = STATE_ACTIVE
  286.  
  287.             elif state == STATE_ACTIVE:
  288.                 log.debug("%s State: Active" % ("*"*20))
  289.  
  290.                 if self.copy_type == COPY_TYPE_DEVICE:
  291.                     while True:
  292.                         result_code, copy_state = self.dev.getPML(pml.OID_COPIER_JOB)
  293.  
  294.                         if self.check_for_cancel():
  295.                             self.dev.setPML(pml.OID_COPIER_JOB, pml.COPIER_JOB_IDLE) # cancel
  296.                             state = STATE_ABORTED
  297.                             break
  298.  
  299.                         if copy_state == pml.COPIER_JOB_START:
  300.                             log.debug("state = start")
  301.                             time.sleep(1)
  302.                             continue
  303.  
  304.                         if copy_state == pml.COPIER_JOB_ACTIVE:
  305.                             self.write_queue(STATUS_ACTIVE)
  306.                             log.debug("state = active")
  307.                             time.sleep(2)
  308.                             continue
  309.  
  310.                         elif copy_state == pml.COPIER_JOB_ABORTING:
  311.                             log.debug("state = aborting")
  312.                             state = STATE_ABORTED
  313.                             break
  314.  
  315.                         elif copy_state == pml.COPIER_JOB_IDLE:
  316.                             log.debug("state = idle")
  317.                             state = STATE_SUCCESS
  318.                             break
  319.  
  320.                 elif self.copy_type == COPY_TYPE_AIO_DEVICE:
  321.                     while True:
  322.                         result_code, copy_state = self.dev.getPML(pml.OID_SCAN_TO_PRINTER)
  323.  
  324.                         if self.check_for_cancel():
  325.                             self.dev.setPML(pml.OID_SCAN_TO_PRINTER, pml.SCAN_TO_PRINTER_IDLE) # cancel
  326.                             state = STATE_ABORTED
  327.                             break
  328.  
  329.                         if copy_state == pml.SCAN_TO_PRINTER_START:
  330.                             log.debug("state = start")
  331.                             time.sleep(1)
  332.                             continue
  333.  
  334.                         if copy_state == pml.SCAN_TO_PRINTER_ACTIVE:
  335.                             self.write_queue(STATUS_ACTIVE)
  336.                             log.debug("state = active")
  337.                             time.sleep(2)
  338.                             continue
  339.  
  340.                         elif copy_state == pml.SCAN_TO_PRINTER_ABORTED:
  341.                             log.debug("state = aborting")
  342.                             state = STATE_ABORTED
  343.                             break
  344.  
  345.                         elif copy_state == pml.SCAN_TO_PRINTER_IDLE:
  346.                             log.debug("state = idle")
  347.                             state = STATE_SUCCESS
  348.                             break
  349.  
  350.  
  351.             elif state == STATE_RESET_TOKEN:
  352.                 log.debug("%s State: Release copy token" % ("*"*20))
  353.  
  354.                 try:
  355.                     self.dev.setPML(pml.OID_COPIER_TOKEN, '\x00'*16)
  356.                 except Error:
  357.                     log.error("Unable to release copier token.")
  358.  
  359.                 self.dev.close() # Close the device.
  360.                 
  361.                 state = STATE_DONE
  362.  
  363.  
  364.     def check_for_cancel(self):
  365.         canceled = False
  366.         while self.event_queue.qsize():
  367.             try:
  368.                 event = self.event_queue.get(0)
  369.                 if event == COPY_CANCELED:
  370.                     canceled = True
  371.                     log.debug("Cancel pressed!")
  372.             except Queue.Empty:
  373.                 break
  374.  
  375.         return canceled
  376.  
  377.     def write_queue(self, message):
  378.         if self.update_queue is not None and message != self.prev_update:
  379.             self.update_queue.put(message)
  380.             time.sleep(0)
  381.             self.prev_update = message
  382.